std::unordered_map::operator[]

#include <unordered_map>

Truy cập phần tử có key tương ứng. Điểm đặc biệt của operator[] là nếu key chưa tồn tại trong map, nó sẽ tự động chèn một phần tử mới với key đó và value được khởi tạo mặc định.

mapped_type& operator[](const key_type& key);
mapped_type& operator[](key_type&& key); // (since C++11)

Tham số

`key`

Giá trị của key cần truy cập hoặc chèn.

Giá trị trả về

`mapped_type&`

Trả về tham chiếu đến value tương ứng với key. Nếu key không tồn tại, một phần tử mới với key đó và value mặc định sẽ được chèn vào, và tham chiếu đến value mới đó sẽ được trả về.

Đặc điểm

Truy cập và chèn: Toán tử [] vừa có thể được sử dụng để truy cập phần tử, vừa có thể được sử dụng để chèn phần tử mới (nếu key chưa tồn tại).
Tự động chèn nếu key không tồn tại: Đây là điểm khác biệt quan trọng so với at(). Nếu key không tồn tại, operator[] sẽ tự động chèn phần tử mới, trong khi at() sẽ ném ra ngoại lệ.
Tham chiếu: Toán tử [] trả về tham chiếu đến value, cho phép bạn thay đổi trực tiếp giá trị của phần tử.
Không const: Toán tử [] không phải là hàm const vì nó có thể thay đổi nội dung của std::unordered_map (khi chèn phần tử mới).
Phân biệt với at(): at() chỉ truy cập phần tử, không chèn phần tử mới và ném ra ngoại lệ nếu key không tồn tại. operator[] truy cập hoặc chèn phần tử mới và không ném ngoại lệ.
Cẩn thận khi sử dụng với mục đích kiểm tra: Do operator[] tự động chèn phần tử mới nếu key không tồn tại, bạn cần cẩn thận khi sử dụng nó với mục đích kiểm tra sự tồn tại của key. find() hoặc count() thường phù hợp hơn cho việc này.
Có thể gây phình to bảng băm: Việc sử dụng operator[] với các key không tồn tại có thể dẫn đến việc bảng băm bị phình to (rehashing) ngoài ý muốn nếu số lượng key mới được chèn vào lớn.
Độ phức tạp: Độ phức tạp trung bình của operator[] là O(1) (thời gian hằng số). Trong trường hợp xấu nhất (xung đột hash nhiều), độ phức tạp có thể lên tới O(n), với n là số phần tử trong std::unordered_map.

Ví dụ

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
  std::unordered_map<std::string, int> myumap;

  // Chèn phần tử sử dụng toán tử []
  myumap["apple"] = 1;
  myumap["banana"] = 2;

  // Truy cập phần tử sử dụng toán tử []
  std::cout << "myumap[\"apple\"]: " << myumap["apple"] << '\n'; // Output: myumap["apple"]: 1
  std::cout << "myumap[\"banana\"]: " << myumap["banana"] << '\n'; // Output: myumap["banana"]: 2

  // Thay đổi giá trị sử dụng toán tử []
  myumap["apple"] = 5;

  // Truy cập phần tử không tồn tại (sẽ tự động chèn)
  std::cout << "myumap[\"orange\"]: " << myumap["orange"] << '\n'; // Output: myumap["orange"]: 0 (giá trị mặc định của int)
  myumap["orange"] = 3;

  // In ra các phần tử trong map
  std::cout << "mymap elements:\n";
  for (const auto& pair : myumap) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mymap elements:
  // orange: 3
  // banana: 2
  // apple: 5
  // (thứ tự có thể khác)

  return 0;
}

Các hàm liên quan


at	Truy cập phần tử có `key` cho trước
find	Tìm kiếm một phần tử có `key` bằng với giá trị key cho trước trong std::unordered_map

Tham số​

key​

Giá trị trả về​

mapped_type&​

Đặc điểm​

Ví dụ​

Các hàm liên quan​